/**
 * 统一错误处理工具
 * 提供统一的错误捕获、处理和提示
 */

const StateManager = require('./state');

class ErrorHandler {
  /**
   * 默认错误消息映射
   */
  static ERROR_MESSAGES = {
    NETWORK_ERROR: '网络连接失败，请检查网络设置',
    TIMEOUT: '请求超时，请稍后重试',
    UNAUTHORIZED: '登录已过期，请重新登录',
    FORBIDDEN: '没有权限访问',
    NOT_FOUND: '资源不存在',
    SERVER_ERROR: '服务器错误，请稍后重试',
    UNKNOWN: '操作失败，请稍后重试'
  };

  /**
   * 处理API错误
   * @param {Error|Object} error - 错误对象
   * @param {Object} options - 配置选项
   * @param {Boolean} options.showToast - 是否显示Toast提示，默认true
   * @param {String} options.defaultMessage - 默认错误消息
   * @returns {String} 错误消息
   */
  static handleApiError(error, options = {}) {
    const { showToast = true, defaultMessage } = options;
    
    let message = defaultMessage || this.ERROR_MESSAGES.UNKNOWN;

    // 处理不同类型的错误
    if (error instanceof Error) {
      const errorMessage = error.message || error.toString();
      
      // 网络错误
      if (errorMessage.includes('network') || errorMessage.includes('网络')) {
        message = this.ERROR_MESSAGES.NETWORK_ERROR;
      }
      // 超时错误
      else if (errorMessage.includes('timeout') || errorMessage.includes('超时')) {
        message = this.ERROR_MESSAGES.TIMEOUT;
      }
      // 401未授权
      else if (errorMessage.includes('Unauthorized') || errorMessage.includes('401')) {
        message = this.ERROR_MESSAGES.UNAUTHORIZED;
      }
      // 403禁止访问
      else if (errorMessage.includes('Forbidden') || errorMessage.includes('403')) {
        message = this.ERROR_MESSAGES.FORBIDDEN;
      }
      // 404未找到
      else if (errorMessage.includes('Not Found') || errorMessage.includes('404')) {
        message = this.ERROR_MESSAGES.NOT_FOUND;
      }
      // 500服务器错误
      else if (errorMessage.includes('Server Error') || errorMessage.includes('500')) {
        message = this.ERROR_MESSAGES.SERVER_ERROR;
      }
      // 其他错误消息
      else if (errorMessage && errorMessage.length > 0 && errorMessage.length < 50) {
        message = errorMessage;
      }
    } else if (typeof error === 'string') {
      message = error;
    } else if (error && error.message) {
      message = error.message;
    }

    if (showToast) {
      StateManager.showError(message);
    }

    return message;
  }

  /**
   * 处理页面错误
   * @param {Error} error - 错误对象
   * @param {Object} context - 页面上下文（this）
   * @param {String} defaultMessage - 默认错误消息
   */
  static handlePageError(error, context, defaultMessage) {
    const message = this.handleApiError(error, { showToast: true, defaultMessage });
    
    // 更新页面错误状态
    if (context && typeof context.setData === 'function') {
      context.setData({
        error: message,
        loading: false
      });
    }

    // 记录错误日志（开发环境）
    if (process.env.NODE_ENV === 'development') {
      console.error('Page Error:', error);
    }
  }

  /**
   * 包装异步函数，自动捕获错误
   * @param {Function} asyncFn - 异步函数
   * @param {Object} options - 配置选项
   * @returns {Function} 包装后的函数
   */
  static wrapAsync(asyncFn, options = {}) {
    return async (...args) => {
      try {
        return await asyncFn(...args);
      } catch (error) {
        this.handleApiError(error, options);
        throw error;
      }
    };
  }
}

module.exports = ErrorHandler;

